const Comments = require('../models/Comments')

class CommentsCtl {
    async find(ctx) {
        const {questionId, answerId} = ctx.params
        
        // 一级评论id是可选参数，可能没有二级评论，存在即显示
        const rootCommentId = ctx.query.rootCommentId

        // Math.max在接受的参数中选择最大的一个
        // 每页条数
        const perPage = Math.max(ctx.query.perPage * 1, 1)
        // 当前页
        const page = Math.max(ctx.query.page * 1, 1)
        // 跳过的条数
        const skip = (page - 1) * perPage
        // 分页 模糊搜索
        const q = new RegExp(ctx.query.q)
        const total = await Comments.find({
            content: q,
            questionId,
            answerId,
            rootCommentId
        }).countDocuments()
        const totalPage = Math.ceil(total / perPage)

        // 返回评论需要评论人的信息，使用populate
        const list = await Comments.find({
            content: q,
            questionId,
            answerId,
            rootCommentId
        }).limit(perPage).skip(skip)
        .populate('commentator replyTo').sort({createdAt: -1})
        ctx.body = {
            list,
            page,
            perPage,
            total,
            totalPage
        }

    }

    async checkCommentExist(ctx, next) {
        const comment = await Comments.findById(ctx.params.id).select('+commentator')
        if (!comment) {
            ctx.throw(404, '评论不存在')
        }
        // ctx.params.questionId存在才检查，是不是一致
        if (ctx.params.questionId && comment.questionId !== ctx.params.questionId) {
            ctx.throw(404, '该问题下没有此评论')
        }
        if (ctx.params.answerId && comment.answerId !== ctx.params.answerId) {
            ctx.throw(404, '该答案下没有此评论')
        }
        // 存储评论到state中
        ctx.state.comment = comment
        await next()
    }

    async findById(ctx) {
        const {fields = ''} = ctx.query
        const selectFields = fields.split(',').filter(f => f).map(f => f => '+ ' + f).join('')
        const answer = await Comments.findById(ctx.params.id).select(selectFields)
            .populate('commentator replyTo')
        ctx.body = answer
    }

    async create(ctx) {
        ctx.verifyParams({
            // 创建一级评论
            content: {type: 'string', required: true},

            // 以下为创建二级评论的参数，当然一级评论的参数也要
            // 一级评论id
            rootCommentId: {type: 'string', required: false},
            // 评论给哪个用户的id
            replyTo: {type: 'string', required: false},
        })
        // 评论人
        const commentator = ctx.state.user._id
        // 问题的id 答案的id
        const {questionId, answerId} = ctx.params
        var comment = await new Comments({...ctx.request.body, answerId, questionId, commentator}).save()
        ctx.body = comment
    }

    async checkCommentator(ctx, next) {
        const {comment} = ctx.state
        if (comment.commentator.toString() !== ctx.state.user._id) {
            ctx.throw(403, '没有权限')
        }
        await next()
    }

    async update(ctx) {
        ctx.verifyParams({
            content: {type: 'string', required: false}
        })
        // 只更新一级评论，不更新二级评论
        const {content} = ctx.request.body
        // await ctx.state.comment.update(content)
        const comment = await Comments.findByIdAndUpdate(ctx.params.id, {content})
        // ctx.body = ctx.state.comment
        ctx.body = comment
    }

    async remove(ctx) {
        await Comments.findByIdAndRemove(ctx.params.id)
        ctx.status = 204
    }
}

module.exports = new CommentsCtl()
